home *** CD-ROM | disk | FTP | other *** search
/ Total Network Tools 2002 / NextStepPublishing-TotalNetworkTools2002-Win95.iso / Archive / Misc Servers / Zope.exe / FTP_SERVER.PY < prev    next >
Encoding:
Python Source  |  2000-07-05  |  32.5 KB  |  1,130 lines
  1. # -*- Mode: Python; tab-width: 4 -*-
  2.  
  3. #    Author: Sam Rushing <rushing@nightmare.com>
  4. #    Copyright 1996-2000 by Sam Rushing
  5. #                         All Rights Reserved.
  6. #
  7.  
  8. RCS_ID =  '$Id: ftp_server.py,v 1.12.4.1 2000/07/05 14:21:44 brian Exp $'
  9.  
  10. # An extensible, configurable, asynchronous FTP server.
  11. # 
  12. # All socket I/O is non-blocking, however file I/O is currently
  13. # blocking.  Eventually file I/O may be made non-blocking, too, if it
  14. # seems necessary.  Currently the only CPU-intensive operation is
  15. # getting and formatting a directory listing.  [this could be moved
  16. # into another process/directory server, or another thread?]
  17. #
  18. # Only a subset of RFC 959 is implemented, but much of that RFC is
  19. # vestigial anyway.  I've attempted to include the most commonly-used
  20. # commands, using the feature set of wu-ftpd as a guide.
  21.  
  22. import asyncore
  23. import asynchat
  24.  
  25. import os
  26. import regsub
  27. import socket
  28. import stat
  29. import string
  30. import sys
  31. import time
  32.  
  33. # TODO: implement a directory listing cache.  On very-high-load
  34. # servers this could save a lot of disk abuse, and possibly the
  35. # work of computing emulated unix ls output.
  36.  
  37. # Potential security problem with the FTP protocol?  I don't think
  38. # there's any verification of the origin of a data connection.  Not
  39. # really a problem for the server (since it doesn't send the port
  40. # command, except when in PASV mode) But I think a data connection
  41. # could be spoofed by a program with access to a sniffer - it could
  42. # watch for a PORT command to go over a command channel, and then
  43. # connect to that port before the server does.
  44.  
  45. # Unix user id's:
  46. # In order to support assuming the id of a particular user,
  47. # it seems there are two options:
  48. # 1) fork, and seteuid in the child
  49. # 2) carefully control the effective uid around filesystem accessing
  50. #    methods, using try/finally. [this seems to work]
  51.  
  52. VERSION = string.split(RCS_ID)[2]
  53.  
  54. from counter import counter
  55. import producers
  56. import status_handler
  57. import logger
  58. import string
  59.  
  60. class ftp_channel (asynchat.async_chat):
  61.  
  62.     # defaults for a reliable __repr__
  63.     addr = ('unknown','0')
  64.  
  65.     # unset this in a derived class in order
  66.     # to enable the commands in 'self.write_commands'
  67.     read_only = 1
  68.     write_commands = ['appe','dele','mkd','rmd','rnfr','rnto','stor','stou']
  69.  
  70.     restart_position = 0
  71.  
  72.     # comply with (possibly troublesome) RFC959 requirements
  73.     # This is necessary to correctly run an active data connection
  74.     # through a firewall that triggers on the source port (expected
  75.     # to be 'L-1', or 20 in the normal case).
  76.     bind_local_minus_one = 0
  77.  
  78.     def __init__ (self, server, conn, addr):
  79.         self.server = server
  80.         self.current_mode = 'a'
  81.         self.addr = addr
  82.         asynchat.async_chat.__init__ (self, conn)
  83.         self.set_terminator ('\r\n')
  84.  
  85.         # client data port.  Defaults to 'the same as the control connection'.
  86.         self.client_addr = (addr[0], 21)
  87.  
  88.         self.client_dc = None
  89.         self.in_buffer = ''
  90.         self.closing = 0
  91.         self.passive_acceptor = None
  92.         self.passive_connection = None
  93.         self.filesystem = None
  94.         self.authorized = 0
  95.         # send the greeting
  96.         self.respond (
  97.             '220 %s FTP server (Medusa Async V%s [experimental]) ready.' % (
  98.                 self.server.hostname,
  99.                 VERSION
  100.                 )
  101.             )
  102.  
  103. #    def __del__ (self):
  104. #        print 'ftp_channel.__del__()'
  105.  
  106.     # --------------------------------------------------
  107.     # async-library methods
  108.     # --------------------------------------------------
  109.  
  110.     def handle_expt (self):
  111.         # this is handled below.  not sure what I could
  112.         # do here to make that code less kludgish.
  113.         pass
  114.  
  115.     def collect_incoming_data (self, data):
  116.         self.in_buffer = self.in_buffer + data
  117.         if len(self.in_buffer) > 4096:
  118.             # silently truncate really long lines
  119.             # (possible denial-of-service attack)
  120.             self.in_buffer = ''
  121.  
  122.     def found_terminator (self):
  123.  
  124.         line = self.in_buffer
  125.  
  126.         if not len(line):
  127.             return
  128.  
  129.         sp = string.find (line, ' ')
  130.         if sp != -1:
  131.             line = [line[:sp], line[sp+1:]]
  132.         else:
  133.             line = [line]
  134.  
  135.         command = string.lower (line[0])
  136.         # watch especially for 'urgent' abort commands.
  137.         if string.find (command, 'abor') != -1:
  138.             # strip off telnet sync chars and the like...
  139.             while command and command[0] not in string.letters:
  140.                 command = command[1:]
  141.         fun_name = 'cmd_%s' % command
  142.         if command != 'pass':
  143.             self.log ('<== %s' % repr(self.in_buffer)[1:-1])
  144.         else:
  145.             self.log ('<== %s' % line[0]+' <password>')
  146.         self.in_buffer = ''
  147.         if not hasattr (self, fun_name):
  148.             self.command_not_understood (line[0])
  149.             return
  150.         fun = getattr (self, fun_name)
  151.         if (not self.authorized) and (command not in ('user', 'pass', 'help', 'quit')):
  152.             self.respond ('530 Please log in with USER and PASS')
  153.         elif (not self.check_command_authorization (command)):
  154.             self.command_not_authorized (command)
  155.         else:
  156.             try:
  157.                 result = apply (fun, (line,))
  158.             except:
  159.                 self.server.total_exceptions.increment()
  160.                 (file, fun, line), t,v, tbinfo = asyncore.compact_traceback()
  161.                 if self.client_dc:
  162.                     try:
  163.                         self.client_dc.close()
  164.                     except:
  165.                         pass
  166.                 self.respond (
  167.                     '451 Server Error: %s, %s: file: %s line: %s' % (
  168.                         t,v,file,line,
  169.                         )
  170.                     )
  171.  
  172.     closed = 0
  173.     def close (self):
  174.         if not self.closed:
  175.             self.closed = 1
  176.             if self.passive_acceptor:
  177.                 self.passive_acceptor.close()
  178.             if self.client_dc:
  179.                 self.client_dc.close()
  180.             self.server.closed_sessions.increment()
  181.             asynchat.async_chat.close (self)
  182.  
  183.     # --------------------------------------------------
  184.     # filesystem interface functions.
  185.     # override these to provide access control or perform
  186.     # other functions.
  187.     # --------------------------------------------------
  188.  
  189.     def cwd (self, line):
  190.         return self.filesystem.cwd (line[1])
  191.  
  192.     def cdup (self, line):
  193.         return self.filesystem.cdup()
  194.  
  195.     def open (self, path, mode):
  196.         return self.filesystem.open (path, mode)
  197.  
  198.     # returns a producer
  199.     def listdir (self, path, long=0):
  200.         return self.filesystem.listdir (path, long)
  201.  
  202.     def get_dir_list (self, line, long=0):
  203.         # we need to scan the command line for arguments to '/bin/ls'...
  204.         args = line[1:]
  205.         path_args = []
  206.         for arg in args:
  207.             if arg[0] != '-':
  208.                 path_args.append (arg)
  209.             else:
  210.                 # ignore arguments
  211.                 pass
  212.         if len(path_args) < 1:
  213.             dir = '.'
  214.         else:
  215.             dir = path_args[0]
  216.         return self.listdir (dir, long)
  217.  
  218.     # --------------------------------------------------
  219.     # authorization methods
  220.     # --------------------------------------------------
  221.  
  222.     def check_command_authorization (self, command):
  223.         if command in self.write_commands and self.read_only:
  224.             return 0
  225.         else:
  226.             return 1
  227.  
  228.     # --------------------------------------------------
  229.     # utility methods
  230.     # --------------------------------------------------
  231.  
  232.     def log (self, message):
  233.         self.server.logger.log (
  234.             self.addr[0],
  235.             '%d %s' % (
  236.                 self.addr[1], message
  237.                 )
  238.             )
  239.  
  240.     def respond (self, resp):
  241.         self.log ('==> %s' % resp)
  242.         self.push (resp + '\r\n')
  243.  
  244.     def command_not_understood (self, command):
  245.         self.respond ("500 '%s': command not understood." % command)
  246.  
  247.     def command_not_authorized (self, command):
  248.         self.respond (
  249.             "530 You are not authorized to perform the '%s' command" % (
  250.                 command
  251.                 )
  252.             )
  253.  
  254.     def make_xmit_channel (self):
  255.         # In PASV mode, the connection may or may _not_ have been made
  256.         # yet.  [although in most cases it is... FTP Explorer being
  257.         # the only exception I've yet seen].  This gets somewhat confusing
  258.         # because things may happen in any order...
  259.         pa = self.passive_acceptor
  260.         if pa:
  261.             if pa.ready:
  262.                 # a connection has already been made.
  263.                 conn, addr = self.passive_acceptor.ready
  264.                 cdc = xmit_channel (self, addr)
  265.                 cdc.set_socket (conn)
  266.                 cdc.connected = 1
  267.                 self.passive_acceptor.close()
  268.                 self.passive_acceptor = None                
  269.             else:
  270.                 # we're still waiting for a connect to the PASV port.
  271.                 cdc = xmit_channel (self)
  272.         else:
  273.             # not in PASV mode.
  274.             ip, port = self.client_addr
  275.             cdc = xmit_channel (self, self.client_addr)
  276.             cdc.create_socket (socket.AF_INET, socket.SOCK_STREAM)
  277.             if self.bind_local_minus_one:
  278.                 cdc.bind (('', self.server.port - 1))
  279.             try:
  280.                 cdc.connect ((ip, port))
  281.             except socket.error, why:
  282.                 self.respond ("425 Can't build data connection")
  283.         self.client_dc = cdc
  284.  
  285.     # pretty much the same as xmit, but only right on the verge of
  286.     # being worth a merge.
  287.     def make_recv_channel (self, fd):
  288.         pa = self.passive_acceptor
  289.         if pa:
  290.             if pa.ready:
  291.                 # a connection has already been made.
  292.                 conn, addr = pa.ready
  293.                 cdc = recv_channel (self, addr, fd)
  294.                 cdc.set_socket (conn)
  295.                 cdc.connected = 1
  296.                 self.passive_acceptor.close()
  297.                 self.passive_acceptor = None                
  298.             else:
  299.                 # we're still waiting for a connect to the PASV port.
  300.                 cdc = recv_channel (self, None, fd)
  301.         else:
  302.             # not in PASV mode.
  303.             ip, port = self.client_addr
  304.             cdc = recv_channel (self, self.client_addr, fd)
  305.             cdc.create_socket (socket.AF_INET, socket.SOCK_STREAM)
  306.             try:
  307.                 cdc.connect ((ip, port))
  308.             except socket.error, why:
  309.                 self.respond ("425 Can't build data connection")
  310.         self.client_dc = cdc
  311.  
  312.     type_map = {
  313.         'a':'ASCII',
  314.         'i':'Binary',
  315.         'e':'EBCDIC',
  316.         'l':'Binary'
  317.         }
  318.  
  319.     type_mode_map = {
  320.         'a':'t',
  321.         'i':'b',
  322.         'e':'b',
  323.         'l':'b'
  324.         }
  325.  
  326.     # --------------------------------------------------
  327.     # command methods
  328.     # --------------------------------------------------
  329.  
  330.     def cmd_type (self, line):
  331.         'specify data transfer type'
  332.         # ascii, ebcdic, image, local <byte size>
  333.         t = string.lower (line[1])
  334.         # no support for EBCDIC
  335.         # if t not in ['a','e','i','l']:
  336.         if t not in ['a','i','l']:
  337.             self.command_not_understood (string.join (line))
  338.         elif t == 'l' and (len(line) > 2 and line[2] != '8'):
  339.             self.respond ('504 Byte size must be 8')
  340.         else:
  341.             self.current_mode = t
  342.             self.respond ('200 Type set to %s.' % self.type_map[t])
  343.  
  344.  
  345.     def cmd_quit (self, line):
  346.         'terminate session'
  347.         self.respond ('221 Goodbye.')
  348.         self.close_when_done()
  349.  
  350.     def cmd_port (self, line):
  351.         'specify data connection port'
  352.         info = string.split (line[1], ',')
  353.         ip = string.join (info[:4], '.')
  354.         port = string.atoi(info[4])*256 + string.atoi(info[5])
  355.         # how many data connections at a time?
  356.         # I'm assuming one for now...
  357.         # TODO: we should (optionally) verify that the
  358.         # ip number belongs to the client.  [wu-ftpd does this?]
  359.         self.client_addr = (ip, port)
  360.         self.respond ('200 PORT command successful.')
  361.  
  362.     def new_passive_acceptor (self):
  363.         # ensure that only one of these exists at a time.
  364.         if self.passive_acceptor is not None:
  365.             self.passive_acceptor.close()
  366.             self.passive_acceptor = None
  367.         self.passive_acceptor = passive_acceptor (self)
  368.         return self.passive_acceptor
  369.  
  370.     def cmd_pasv (self, line):
  371.         'prepare for server-to-server transfer'
  372.         pc = self.new_passive_acceptor()
  373.         port = pc.addr[1]
  374.         ip_addr = pc.control_channel.getsockname()[0]
  375.         self.respond (
  376.             '227 Entering Passive Mode (%s,%d,%d)' % (
  377.                 string.join (string.split (ip_addr, '.'), ','),
  378.                 port/256,
  379.                 port%256
  380.                 )
  381.             )
  382.         self.client_dc = None
  383.  
  384.     def cmd_nlst (self, line):
  385.         'give name list of files in directory'
  386.         # ncftp adds the -FC argument for the user-visible 'nlist'
  387.         # command.  We could try to emulate ls flags, but not just yet.
  388.         if '-FC' in line:
  389.             line.remove ('-FC')
  390.         try:
  391.             dir_list_producer = self.get_dir_list (line, 0)
  392.         except os.error, why:
  393.             self.respond ('550 Could not list directory: %s' % repr(why))
  394.             return
  395.         self.respond (
  396.             '150 Opening %s mode data connection for file list' % (
  397.                 self.type_map[self.current_mode]
  398.                 )
  399.             )
  400.         self.make_xmit_channel()
  401.         self.client_dc.push_with_producer (dir_list_producer)
  402.         self.client_dc.close_when_done()
  403.  
  404.     def cmd_list (self, line):
  405.         'give list files in a directory'
  406.         try:
  407.             dir_list_producer = self.get_dir_list (line, 1)
  408.         except os.error, why:
  409.             self.respond ('550 Could not list directory: %s' % repr(why))
  410.             return
  411.         self.respond (
  412.             '150 Opening %s mode data connection for file list' % (
  413.                 self.type_map[self.current_mode]
  414.                 )
  415.             )
  416.         self.make_xmit_channel()
  417.         self.client_dc.push_with_producer (dir_list_producer)
  418.         self.client_dc.close_when_done()
  419.  
  420.     def cmd_cwd (self, line):
  421.         'change working directory'
  422.         if self.cwd (line):
  423.             self.respond ('250 CWD command successful.')
  424.         else:
  425.             self.respond ('550 No such directory.')            
  426.  
  427.     def cmd_cdup (self, line):
  428.         'change to parent of current working directory'
  429.         if self.cdup(line):
  430.             self.respond ('250 CDUP command successful.')
  431.         else:
  432.             self.respond ('550 No such directory.')
  433.         
  434.     def cmd_pwd (self, line):
  435.         'print the current working directory'
  436.         self.respond (
  437.             '257 "%s" is the current directory.' % (
  438.                 self.filesystem.current_directory()
  439.                 )
  440.             )
  441.  
  442.     # modification time
  443.     # example output:
  444.     # 213 19960301204320
  445.     def cmd_mdtm (self, line):
  446.         'show last modification time of file'
  447.         filename = line[1]
  448.         if not self.filesystem.isfile (filename):
  449.             self.respond ('550 "%s" is not a file' % filename)
  450.         else:
  451.             mtime = time.gmtime(self.filesystem.stat(filename)[stat.ST_MTIME])
  452.             self.respond (
  453.                 '213 %4d%02d%02d%02d%02d%02d' % (
  454.                     mtime[0],
  455.                     mtime[1],
  456.                     mtime[2],
  457.                     mtime[3],
  458.                     mtime[4],
  459.                     mtime[5]
  460.                     )
  461.                 )
  462.  
  463.     def cmd_noop (self, line):
  464.         'do nothing'
  465.         self.respond ('200 NOOP command successful.')
  466.  
  467.     def cmd_size (self, line):
  468.         'return size of file'
  469.         filename = line[1]
  470.         if not self.filesystem.isfile (filename):
  471.             self.respond ('550 "%s" is not a file' % filename)
  472.         else:
  473.             self.respond (
  474.                 '213 %d' % (self.filesystem.stat(filename)[stat.ST_SIZE])
  475.                 )
  476.  
  477.     def cmd_retr (self, line):
  478.         'retrieve a file'
  479.         if len(line) < 2:
  480.             self.command_not_understood (string.join (line))
  481.         else:
  482.             file = line[1]
  483.             if not self.filesystem.isfile (file):
  484.                 self.log_info ('checking %s' % file)
  485.                 self.respond ('550 No such file')
  486.             else:
  487.                 try:
  488.                     # FIXME: for some reason, 'rt' isn't working on win95
  489.                     mode = 'r'+self.type_mode_map[self.current_mode]
  490.                     fd = self.open (file, mode)
  491.                 except IOError, why:
  492.                     self.respond ('553 could not open file for reading: %s' % (repr(why)))
  493.                     return
  494.                 self.respond (
  495.                     "150 Opening %s mode data connection for file '%s'" % (
  496.                         self.type_map[self.current_mode],
  497.                         file
  498.                         )
  499.                     )
  500.                 self.make_xmit_channel()
  501.  
  502.                 if self.restart_position:
  503.                     # try to position the file as requested, but
  504.                     # give up silently on failure (the 'file object'
  505.                     # may not support seek())
  506.                     try:
  507.                         fd.seek (self.restart_position)
  508.                     except:
  509.                         pass
  510.                     self.restart_position = 0
  511.  
  512.                 self.client_dc.push_with_producer (
  513.                     file_producer (self, self.client_dc, fd)
  514.                     )
  515.                 self.client_dc.close_when_done()
  516.  
  517.     def cmd_stor (self, line, mode='wb'):
  518.         'store a file'
  519.         if len (line) < 2:
  520.             self.command_not_understood (string.join (line))
  521.         else:
  522.             if self.restart_position:
  523.                 restart_position = 0
  524.                 self.respond ('553 restart on STOR not yet supported')
  525.                 return
  526.             file = line[1]
  527.             # todo: handle that type flag
  528.             try:
  529.                 fd = self.open (file, mode)
  530.             except IOError, why:
  531.                 self.respond ('553 could not open file for writing: %s' % (repr(why)))
  532.                 return
  533.             self.respond (
  534.                 '150 Opening %s connection for %s' % (
  535.                     self.type_map[self.current_mode],
  536.                     file
  537.                     )
  538.                 )
  539.             self.make_recv_channel (fd)
  540.  
  541.     def cmd_abor (self, line):
  542.         'abort operation'
  543.         if self.client_dc:
  544.             self.client_dc.close()
  545.         self.respond ('226 ABOR command successful.')
  546.  
  547.     def cmd_appe (self, line):
  548.         'append to a file'
  549.         return self.cmd_stor (line, 'ab')
  550.  
  551.     def cmd_dele (self, line):
  552.         if len (line) != 2:
  553.             self.command_not_understood (string.join (line))
  554.         else:
  555.             file = line[1]
  556.             if self.filesystem.isfile (file):
  557.                 try:
  558.                     self.filesystem.unlink (file)
  559.                     self.respond ('250 DELE command successful.')
  560.                 except:
  561.                     self.respond ('550 error deleting file.')
  562.             else:
  563.                 self.respond ('550 %s: No such file.' % file)
  564.  
  565.     def cmd_mkd (self, line):
  566.         if len (line) != 2:
  567.             self.command.not_understood (string.join (line))
  568.         else:
  569.             path = line[1]
  570.             try:
  571.                 self.filesystem.mkdir (path)
  572.                 self.respond ('257 MKD command successful.')
  573.             except:
  574.                 self.respond ('550 error creating directory.')
  575.  
  576.     def cmd_rmd (self, line):
  577.         if len (line) != 2:
  578.             self.command.not_understood (string.join (line))
  579.         else:
  580.             path = line[1]
  581.             try:
  582.                 self.filesystem.rmdir (path)
  583.                 self.respond ('250 RMD command successful.')
  584.             except:
  585.                 self.respond ('550 error removing directory.')
  586.  
  587.     def cmd_user (self, line):
  588.         'specify user name'
  589.         if len(line) > 1:
  590.             self.user = line[1]
  591.             self.respond ('331 Password required.')
  592.         else:
  593.             self.command_not_understood (string.join (line))
  594.  
  595.     def cmd_pass (self, line):
  596.         'specify password'
  597.         if len(line) < 2:
  598.             pw = ''
  599.         else:
  600.             pw = line[1]
  601.         result, message, fs = self.server.authorizer.authorize (self, self.user, pw)
  602.         if result:
  603.             self.respond ('230 %s' % message)
  604.             self.filesystem = fs
  605.             self.authorized = 1
  606.             self.log_info('Successful login: Filesystem=%s' % repr(fs))
  607.         else:
  608.             self.respond ('530 %s' % message)
  609.  
  610.     def cmd_rest (self, line):
  611.         'restart incomplete transfer'
  612.         try:
  613.             pos = string.atoi (line[1])
  614.         except ValueError:
  615.             self.command_not_understood (string.join (line))
  616.         self.restart_position = pos
  617.         self.respond (
  618.             '350 Restarting at %d. Send STORE or RETRIEVE to initiate transfer.' % pos
  619.             )
  620.  
  621.     def cmd_stru (self, line):
  622.         'obsolete - set file transfer structure'
  623.         if line[1] in 'fF':
  624.             # f == 'file'
  625.             self.respond ('200 STRU F Ok')
  626.         else:
  627.             self.respond ('504 Unimplemented STRU type')
  628.  
  629.     def cmd_mode (self, line):
  630.         'obsolete - set file transfer mode'
  631.         if line[1] in 'sS':
  632.             # f == 'file'
  633.             self.respond ('200 MODE S Ok')
  634.         else:
  635.             self.respond ('502 Unimplemented MODE type')
  636.  
  637. # The stat command has two personalities.  Normally it returns status
  638. # information about the current connection.  But if given an argument,
  639. # it is equivalent to the LIST command, with the data sent over the
  640. # control connection.  Strange.  But wuftpd, ftpd, and nt's ftp server
  641. # all support it.
  642. #
  643. ##    def cmd_stat (self, line):
  644. ##        'return status of server'
  645. ##        pass
  646.  
  647.     def cmd_syst (self, line):
  648.         'show operating system type of server system'
  649.         # Replying to this command is of questionable utility, because
  650.         # this server does not behave in a predictable way w.r.t. the
  651.         # output of the LIST command.  We emulate Unix ls output, but
  652.         # on win32 the pathname can contain drive information at the front
  653.         # Currently, the combination of ensuring that os.sep == '/'
  654.         # and removing the leading slash when necessary seems to work.
  655.         # [cd'ing to another drive also works]
  656.         #
  657.         # This is how wuftpd responds, and is probably
  658.         # the most expected.  The main purpose of this reply is so that
  659.         # the client knows to expect Unix ls-style LIST output.
  660.         self.respond ('215 UNIX Type: L8')
  661.         # one disadvantage to this is that some client programs
  662.         # assume they can pass args to /bin/ls.
  663.         # a few typical responses:
  664.         # 215 UNIX Type: L8 (wuftpd)
  665.         # 215 Windows_NT version 3.51
  666.         # 215 VMS MultiNet V3.3
  667.         # 500 'SYST': command not understood. (SVR4)
  668.  
  669.     def cmd_help (self, line):
  670.         'give help information'
  671.         # find all the methods that match 'cmd_xxxx',
  672.         # use their docstrings for the help response.
  673.         attrs = dir(self.__class__)
  674.         help_lines = []
  675.         for attr in attrs:
  676.             if attr[:4] == 'cmd_':
  677.                 x = getattr (self, attr)
  678.                 if type(x) == type(self.cmd_help):
  679.                     if x.__doc__:
  680.                         help_lines.append ('\t%s\t%s' % (attr[4:], x.__doc__))
  681.         if help_lines:
  682.             self.push ('214-The following commands are recognized\r\n')
  683.             self.push_with_producer (producers.lines_producer (help_lines))
  684.             self.push ('214\r\n')
  685.         else:
  686.             self.push ('214-\r\n\tHelp Unavailable\r\n214\r\n')
  687.  
  688. class ftp_server (asyncore.dispatcher):
  689.     # override this to spawn a different FTP channel class.
  690.     ftp_channel_class = ftp_channel
  691.  
  692.     SERVER_IDENT = 'FTP Server (V%s)' % VERSION
  693.  
  694.     def __init__ (
  695.         self,
  696.         authorizer,
  697.         hostname    =None,
  698.         ip            ='',
  699.         port        =21,
  700.         resolver    =None,
  701.         logger_object=logger.file_logger (sys.stdout)
  702.         ):
  703.         self.ip = ip
  704.         self.port = port
  705.         self.authorizer = authorizer
  706.  
  707.         if hostname is None:
  708.             self.hostname = socket.gethostname()
  709.         else:
  710.             self.hostname = hostname
  711.  
  712.         # statistics
  713.         self.total_sessions = counter()
  714.         self.closed_sessions = counter()
  715.         self.total_files_out = counter()
  716.         self.total_files_in = counter()
  717.         self.total_bytes_out = counter()
  718.         self.total_bytes_in = counter()
  719.         self.total_exceptions = counter()
  720.         #
  721.         asyncore.dispatcher.__init__ (self)
  722.         self.create_socket (socket.AF_INET, socket.SOCK_STREAM)
  723.  
  724.         self.set_reuse_addr()
  725.         self.bind ((self.ip, self.port))
  726.         self.listen (5)
  727.  
  728.         if not logger_object:
  729.             logger_object = sys.stdout
  730.  
  731.         if resolver:
  732.             self.logger = logger.resolving_logger (resolver, logger_object)
  733.         else:
  734.             self.logger = logger.unresolving_logger (logger_object)
  735.  
  736.         self.log_info('FTP server started at %s\n\tAuthorizer:%s\n\tHostname: %s\n\tPort: %d' % (
  737.             time.ctime(time.time()),
  738.             repr (self.authorizer),
  739.             self.hostname,
  740.             self.port)
  741.             )
  742.  
  743.     def writable (self):
  744.         return 0
  745.  
  746.     def handle_read (self):
  747.         pass
  748.  
  749.     def handle_connect (self):
  750.         pass
  751.  
  752.     def handle_accept (self):
  753.         conn, addr = self.accept()
  754.         self.total_sessions.increment()
  755.         self.log_info('Incoming connection from %s:%d' % (addr[0], addr[1]))
  756.         self.ftp_channel_class (self, conn, addr)
  757.  
  758.     # return a producer describing the state of the server
  759.     def status (self):
  760.  
  761.         def nice_bytes (n):
  762.             return string.join (status_handler.english_bytes (n))
  763.  
  764.         return producers.lines_producer (
  765.             ['<h2>%s</h2>'                % self.SERVER_IDENT,
  766.              '<br>Listening on <b>Host:</b> %s' % self.hostname,
  767.              '<b>Port:</b> %d'            % self.port,
  768.              '<br>Sessions',
  769.              '<b>Total:</b> %s'            % self.total_sessions,
  770.              '<b>Current:</b> %d'        % (self.total_sessions.as_long() - self.closed_sessions.as_long()),
  771.              '<br>Files',
  772.              '<b>Sent:</b> %s'            % self.total_files_out,
  773.              '<b>Received:</b> %s'        % self.total_files_in,
  774.              '<br>Bytes',
  775.              '<b>Sent:</b> %s'            % nice_bytes (self.total_bytes_out.as_long()),
  776.              '<b>Received:</b> %s'        % nice_bytes (self.total_bytes_in.as_long()),
  777.              '<br>Exceptions: %s'        % self.total_exceptions,
  778.              ]
  779.             )
  780.  
  781. # ======================================================================
  782. #                         Data Channel Classes
  783. # ======================================================================
  784.  
  785. # This socket accepts a data connection, used when the server has been
  786. # placed in passive mode.  Although the RFC implies that we ought to
  787. # be able to use the same acceptor over and over again, this presents
  788. # a problem: how do we shut it off, so that we are accepting
  789. # connections only when we expect them?  [we can't]
  790. #
  791. # wuftpd, and probably all the other servers, solve this by allowing
  792. # only one connection to hit this acceptor.  They then close it.  Any
  793. # subsequent data-connection command will then try for the default
  794. # port on the client side [which is of course never there].  So the
  795. # 'always-send-PORT/PASV' behavior seems required.
  796. #
  797. # Another note: wuftpd will also be listening on the channel as soon
  798. # as the PASV command is sent.  It does not wait for a data command
  799. # first.
  800.  
  801. # --- we need to queue up a particular behavior:
  802. #  1) xmit : queue up producer[s]
  803. #  2) recv : the file object
  804. #
  805. # It would be nice if we could make both channels the same.  Hmmm..
  806. #
  807.  
  808. class passive_acceptor (asyncore.dispatcher):
  809.     ready = None
  810.  
  811.     def __init__ (self, control_channel):
  812.         # connect_fun (conn, addr)
  813.         asyncore.dispatcher.__init__ (self)
  814.         self.control_channel = control_channel
  815.         self.create_socket (socket.AF_INET, socket.SOCK_STREAM)
  816.         # bind to an address on the interface that the
  817.         # control connection is coming from.
  818.         self.bind ((
  819.             self.control_channel.getsockname()[0],
  820.             0
  821.             ))
  822.         self.addr = self.getsockname()
  823.         self.listen (1)
  824.  
  825. #    def __del__ (self):
  826. #        print 'passive_acceptor.__del__()'
  827.  
  828.     def log (self, *ignore):
  829.         pass
  830.  
  831.     def handle_accept (self):
  832.         conn, addr = self.accept()
  833.         dc = self.control_channel.client_dc
  834.         if dc is not None:
  835.             dc.set_socket (conn)
  836.             dc.addr = addr
  837.             dc.connected = 1
  838.             self.control_channel.passive_acceptor = None
  839.         else:
  840.             self.ready = conn, addr
  841.         self.close()
  842.  
  843.  
  844. class xmit_channel (asynchat.async_chat):
  845.  
  846.     # for an ethernet, you want this to be fairly large, in fact, it
  847.     # _must_ be large for performance comparable to an ftpd.  [64k] we
  848.     # ought to investigate automatically-sized buffers...
  849.  
  850.     ac_out_buffer_size = 16384
  851.     bytes_out = 0
  852.  
  853.     def __init__ (self, channel, client_addr=None):
  854.         self.channel = channel
  855.         self.client_addr = client_addr
  856.         asynchat.async_chat.__init__ (self)
  857.         
  858. #    def __del__ (self):
  859. #        print 'xmit_channel.__del__()'
  860.  
  861.     def log (*args):
  862.         pass
  863.  
  864.     def readable (self):
  865.         return not self.connected
  866.  
  867.     def writable (self):
  868.         return 1
  869.  
  870.     def send (self, data):
  871.         result = asynchat.async_chat.send (self, data)
  872.         self.bytes_out = self.bytes_out + result
  873.         return result
  874.  
  875.     def handle_error (self):
  876.         # usually this is to catch an unexpected disconnect.
  877.         self.log_info ('unexpected disconnect on data xmit channel', 'error')
  878.         try:
  879.             self.close()
  880.         except:
  881.             pass
  882.  
  883.     # TODO: there's a better way to do this.  we need to be able to
  884.     # put 'events' in the producer fifo.  to do this cleanly we need
  885.     # to reposition the 'producer' fifo as an 'event' fifo.
  886.  
  887.     def close (self):
  888.         c = self.channel
  889.         s = c.server
  890.         c.client_dc = None
  891.         s.total_files_out.increment()
  892.         s.total_bytes_out.increment (self.bytes_out)
  893.         if not len(self.producer_fifo):
  894.             c.respond ('226 Transfer complete')
  895.         elif not c.closed:
  896.             c.respond ('426 Connection closed; transfer aborted')
  897.         del c
  898.         del s
  899.         del self.channel
  900.         asynchat.async_chat.close (self)
  901.  
  902. class recv_channel (asyncore.dispatcher):
  903.     def __init__ (self, channel, client_addr, fd):
  904.         self.channel = channel
  905.         self.client_addr = client_addr
  906.         self.fd = fd
  907.         asyncore.dispatcher.__init__ (self)
  908.         self.bytes_in = counter()
  909.  
  910.     def log (self, *ignore):
  911.         pass
  912.  
  913.     def handle_connect (self):
  914.         pass
  915.  
  916.     def writable (self):
  917.         return 0
  918.  
  919.     def recv (*args):
  920.         result = apply (asyncore.dispatcher.recv, args)
  921.         self = args[0]
  922.         self.bytes_in.increment(len(result))
  923.         return result
  924.  
  925.     buffer_size = 8192
  926.  
  927.     def handle_read (self):
  928.         block = self.recv (self.buffer_size)
  929.         if block:
  930.             try:
  931.                 self.fd.write (block)
  932.             except IOError:
  933.                 self.log_info ('got exception writing block...', 'error')
  934.  
  935.     def handle_close (self):
  936.         s = self.channel.server
  937.         s.total_files_in.increment()
  938.         s.total_bytes_in.increment(self.bytes_in.as_long())
  939.         self.fd.close()
  940.         self.channel.respond ('226 Transfer complete.')
  941.         self.close()
  942.  
  943. import filesys
  944.  
  945. # not much of a doorman! 8^)
  946. class dummy_authorizer:
  947.     def __init__ (self, root='/'):
  948.         self.root = root
  949.     def authorize (self, channel, username, password):
  950.         channel.persona = -1, -1
  951.         channel.read_only = 1
  952.         return 1, 'Ok.', filesys.os_filesystem (self.root)
  953.  
  954. class anon_authorizer:
  955.     def __init__ (self, root='/'):
  956.         self.root = root
  957.         
  958.     def authorize (self, channel, username, password):
  959.         if username in ('ftp', 'anonymous'):
  960.             channel.persona = -1, -1
  961.             channel.read_only = 1
  962.             return 1, 'Ok.', filesys.os_filesystem (self.root)
  963.         else:
  964.             return 0, 'Password invalid.', None
  965.  
  966. # ===========================================================================
  967. # Unix-specific improvements
  968. # ===========================================================================
  969.  
  970. if os.name == 'posix':
  971.  
  972.     class unix_authorizer:
  973.         # return a trio of (success, reply_string, filesystem)
  974.         def authorize (self, channel, username, password):
  975.             import crypt
  976.             import pwd
  977.             try:
  978.                 info = pwd.getpwnam (username)
  979.             except KeyError:
  980.                 return 0, 'No such user.', None
  981.             mangled = info[1]
  982.             if crypt.crypt (password, mangled[:2]) == mangled:
  983.                 channel.read_only = 0
  984.                 fs = filesys.schizophrenic_unix_filesystem (
  985.                     '/',
  986.                     info[5],
  987.                     persona = (info[2], info[3])
  988.                     )
  989.                 return 1, 'Login successful.', fs
  990.             else:
  991.                 return 0, 'Password invalid.', None
  992.  
  993.         def __repr__ (self):
  994.             return '<standard unix authorizer>'
  995.  
  996.     # simple anonymous ftp support
  997.     class unix_authorizer_with_anonymous (unix_authorizer):
  998.         def __init__ (self, root=None, real_users=0):
  999.             self.root = root
  1000.             self.real_users = real_users
  1001.  
  1002.         def authorize (self, channel, username, password):
  1003.             if string.lower(username) in ['anonymous', 'ftp']:
  1004.                 import pwd
  1005.                 try:
  1006.                     # ok, here we run into lots of confusion.
  1007.                     # on some os', anon runs under user 'nobody',
  1008.                     # on others as 'ftp'.  ownership is also critical.
  1009.                     # need to investigate.
  1010.                     # linux: new linuxen seem to have nobody's UID=-1,
  1011.                     #    which is an illegal value.  Use ftp.
  1012.                     ftp_user_info = pwd.getpwnam ('ftp')
  1013.                     if string.lower(os.uname()[0]) == 'linux':
  1014.                         nobody_user_info = pwd.getpwnam ('ftp')
  1015.                     else:
  1016.                         nobody_user_info = pwd.getpwnam ('nobody')
  1017.                     channel.read_only = 1
  1018.                     if self.root is None:
  1019.                         self.root = ftp_user_info[5]
  1020.                     fs = filesys.unix_filesystem (self.root, '/')
  1021.                     return 1, 'Anonymous Login Successful', fs
  1022.                 except KeyError:
  1023.                     return 0, 'Anonymous account not set up', None
  1024.             elif self.real_users:
  1025.                 return unix_authorizer.authorize (
  1026.                     self,
  1027.                     channel,
  1028.                     username,
  1029.                     password
  1030.                     )
  1031.             else:
  1032.                 return 0, 'User logins not allowed', None
  1033.  
  1034. class file_producer:
  1035.     block_size = 16384
  1036.     def __init__ (self, server, dc, fd):
  1037.         self.fd = fd
  1038.         self.done = 0
  1039.         
  1040.     def more (self):
  1041.         if self.done:
  1042.             return ''
  1043.         else:
  1044.             block = self.fd.read (self.block_size)
  1045.             if not block:
  1046.                 self.fd.close()
  1047.                 self.done = 1
  1048.             return block
  1049.  
  1050. # usage: ftp_server /PATH/TO/FTP/ROOT PORT
  1051. # for example:
  1052. # $ ftp_server /home/users/ftp 8021
  1053.  
  1054. if os.name == 'posix':
  1055.     def test (port='8021'):
  1056.         import sys
  1057.         fs = ftp_server (
  1058.             unix_authorizer(),
  1059.             port=string.atoi (port)
  1060.             )
  1061.         try:
  1062.             asyncore.loop()
  1063.         except KeyboardInterrupt:
  1064.             self.log_info('FTP server shutting down. (received SIGINT)', 'warning')
  1065.             # close everything down on SIGINT.
  1066.             # of course this should be a cleaner shutdown.
  1067.             asyncore.close_all()
  1068.  
  1069.     if __name__ == '__main__':
  1070.         test (sys.argv[1])
  1071. # not unix
  1072. else:
  1073.     def test ():
  1074.         fs = ftp_server (dummy_authorizer())
  1075.     if __name__ == '__main__':
  1076.         test ()
  1077.  
  1078. # this is the command list from the wuftpd man page
  1079. # '*' means we've implemented it.
  1080. # '!' requires write access
  1081. #
  1082. command_documentation = {
  1083.     'abor':    'abort previous command',                            #*
  1084.     'acct':    'specify account (ignored)',
  1085.     'allo':    'allocate storage (vacuously)',
  1086.     'appe':    'append to a file',                                    #*!
  1087.     'cdup':    'change to parent of current working directory',    #*
  1088.     'cwd':    'change working directory',                            #*
  1089.     'dele':    'delete a file',                                    #!
  1090.     'help':    'give help information',                            #*
  1091.     'list':    'give list files in a directory',                    #*
  1092.     'mkd':    'make a directory',                                    #!
  1093.     'mdtm':    'show last modification time of file',                #*
  1094.     'mode':    'specify data transfer mode',
  1095.     'nlst':    'give name list of files in directory',                #*
  1096.     'noop':    'do nothing',                                        #*
  1097.     'pass':    'specify password',                                    #*
  1098.     'pasv':    'prepare for server-to-server transfer',            #*
  1099.     'port':    'specify data connection port',                        #*
  1100.     'pwd':    'print the current working directory',                #*
  1101.     'quit':    'terminate session',                                #*
  1102.     'rest':    'restart incomplete transfer',                        #*
  1103.     'retr':    'retrieve a file',                                    #*
  1104.     'rmd':    'remove a directory',                                #!
  1105.     'rnfr':    'specify rename-from file name',                    #!
  1106.     'rnto':    'specify rename-to file name',                        #!
  1107.     'site':    'non-standard commands (see next section)',
  1108.     'size':    'return size of file',                                #*
  1109.     'stat':    'return status of server',                            #*
  1110.     'stor':    'store a file',                                        #*!
  1111.     'stou':    'store a file with a unique name',                    #!
  1112.     'stru':    'specify data transfer structure',
  1113.     'syst':    'show operating system type of server system',        #*
  1114.     'type':    'specify data transfer type',                        #*
  1115.     'user':    'specify user name',                                #*
  1116.     'xcup':    'change to parent of current working directory (deprecated)',
  1117.     'xcwd':    'change working directory (deprecated)',
  1118.     'xmkd':    'make a directory (deprecated)',                    #!
  1119.     'xpwd':    'print the current working directory (deprecated)',
  1120.     'xrmd':    'remove a directory (deprecated)',                    #!
  1121. }
  1122.  
  1123.  
  1124. # debugging aid (linux)
  1125. def get_vm_size ():
  1126.     return string.atoi (string.split(open ('/proc/self/stat').readline())[22])
  1127.  
  1128. def print_vm():
  1129.     print 'vm: %8dk' % (get_vm_size()/1024)
  1130.